// 导出所有模型
import { User, IUserDocument, IUserModel } from './user.model';

export { User, IUserDocument, IUserModel };
export { User as UserModel };

// 导出类型定义
export * from '@/types';

/**
 * 基础模型类
 */
export abstract class BaseModel {
  /**
   * 创建查询构建器
   */
  static createQueryBuilder() {
    // 这里可以实现通用的查询构建器逻辑
    return {};
  }

  /**
   * 软删除
   */
  static async softDelete(this: any, id: string) {
    // 实现软删除逻辑
    return this.findByIdAndUpdate(id, { deletedAt: new Date() });
  }

  /**
   * 恢复软删除的记录
   */
  static async restore(this: any, id: string) {
    // 恢复软删除的记录
    return this.findByIdAndUpdate(id, { $unset: { deletedAt: 1 } });
  }

  /**
   * 批量操作
   */
  static async bulkCreate(this: any, data: unknown[]) {
    // 批量创建记录
    return this.insertMany(data);
  }

  /**
   * 分页查询
   */
  static async paginate(this: any, options: {
    page: number;
    limit: number;
    filter?: Record<string, unknown>;
    sort?: Record<string, 1 | -1>;
    populate?: string | string[];
  }) {
    const { page, limit, filter = {}, sort = { createdAt: -1 }, populate } = options;
    const skip = (page - 1) * limit;

    let query = this.find(filter).sort(sort).skip(skip).limit(limit);

    if (populate) {
      if (Array.isArray(populate)) {
        populate.forEach(p => {
          query = query.populate(p);
        });
      } else {
        query = query.populate(populate);
      }
    }

    const [data, total] = await Promise.all([
      query.exec(),
      this.countDocuments(filter),
    ]);

    return {
      data,
      pagination: {
        page,
        limit,
        total,
        totalPages: Math.ceil(total / limit),
        hasNext: page < Math.ceil(total / limit),
        hasPrev: page > 1,
      },
    };
  }
}

/**
 * 模型工厂
 */
export class ModelFactory {
  /**
   * 创建用户
   */
  static createUser(userData: Partial<import('./user.model').IUserDocument>) {
    return new User(userData);
  }
}

/**
 * 数据库种子数据
 */
export class DatabaseSeeder {
  /**
   * 创建管理员用户
   */
  static async createAdminUser() {
    const adminExists = await User.findOne({ role: 'admin' });
    
    if (!adminExists) {
      const admin = new User({
        username: 'admin',
        email: 'admin@example.com',
        password: 'Admin123!@#',
        firstName: 'System',
        lastName: 'Administrator',
        role: 'admin',
        status: 'active',
        emailVerified: true,
      });

      await admin.save();
      return admin;
    }

    return adminExists;
  }

  /**
   * 创建示例数据
   */
  static async seedSampleData() {
    // 创建管理员用户
    await this.createAdminUser();
  }

  /**
   * 清空所有数据（仅用于开发环境）
   */
  static async clearAllData() {
    if (process.env.NODE_ENV === 'production') {
      throw new Error('不能在生产环境中清空数据');
    }

    await Promise.all([
      User.deleteMany({}),
    ]);
  }
}

/**
 * 数据库迁移
 */
export class DatabaseMigrator {
  /**
   * 运行迁移
   */
  static async migrate() {
    // 这里可以实现数据库迁移逻辑
    console.log('开始数据库迁移...');
    
    // 示例：添加新字段的默认值
    await this.addDefaultValues();
    
    console.log('数据库迁移完成');
  }

  /**
   * 添加默认值
   */
  private static async addDefaultValues() {
    // 为没有 emailVerified 字段的用户添加默认值
    await User.updateMany(
      { emailVerified: { $exists: false } },
      { $set: { emailVerified: false } }
    );
  }

  /**
   * 回滚迁移
   */
  static async rollback() {
    console.log('开始回滚数据库迁移...');
    // 实现回滚逻辑
    console.log('数据库迁移回滚完成');
  }
}